I. Field of the Invention
The present invention relates to CDMA (Code Division Multiple Access) cellular telephone and wireless data communications with data rates up to multiple T1 (1.544 Mbps) and higher (>100 Mbps), and to optical CDMA with data rates in the Gbps and higher ranges. Applications are mobile, point-to-point and satellite communication networks. More specifically the present invention relates to novel complex and generalized complex Walsh codes developed to replace current Walsh orthogonal CDMA channelization codes which are real Walsh codes.
II. Description of the Related Art
Current CDMA art is represented by the recent work on multiple access for broadband wireless communications, the G3 (third generation CDMA) proposed standard candidates, the current IS-95 CDMA standard, the early Qualcomm patents, and the real Walsh technology. These are documented in “Multiple Access for Broadband Networks”, IEEE Communications magazine July 2000 Vol. 38 No. 7, “Third Generation Mobile Systems in Europe”, IEEE Personal Communications April 1998 Vol. 5 No. 2, IS-95/IS-95A, the IS-95/IS-95A, the 3G CDMA2000 and W-CDMA, and the listed patents.
Current art using Walsh orthogonal CDMA channelization codes is represented by the scenario described in the following with the aid of equations (1) and FIG. 1,2,3,4. This scenario considers CDMA communications spread over a common frequency band for each of the communication channels with each channel defined by a CDMA code. These CDMA communications channels for each of the users are defined by assigning a unique Walsh orthogonal spreading codes to each user. The Walsh code for each user spreads the user data symbols over the common frequency band. These Walsh encoded user signals are summed and re-spread over the same frequency band by long and short pseudo-noise PN codes, to generate the CDMA communications signal which is modulated and transmitted. The communications link consists of a transmitter, propagation path, and receiver, as well as interfaces and control.
It is assumed that the communication link is in the communications mode with all of the users communicating at the same symbol rate and the synchronization is sufficiently accurate and robust to support this communications mode. In addition, the possible power differences between the users is assumed to be incorporated in the data symbol amplitudes prior to the CDMA encoding in the CDMA transmitter, and the power is uniformly spread over the wideband by proper selection of the CDMA pulse waveform.
Transmitter equations (1) describe a representative real Walsh CDMA encoding for the transmitter in FIG. 1. It is assumed that there are N Walsh code vectors W(u) each of length N chips 1. The code vector is presented by a 1×N N-chip row vector W(u)=[W(u,1), . . . ,W(u,N)] where W(u,n) is chip n of code u. The code vectors are the row vectors of the Walsh matrix W. Walsh code chip n of code vector u has the possible values W(u,n)=+/−1. Each user is assigned a unique Walsh code which allows the code vectors to be. designated by the user symbols u=0, 1, . . . ,N−1 for N Walsh codes. User data symbols 2 are the set of complex symbols {Z(u), u=0,, 1, . . . , N−1) and the set of real symbols (R(uR), I (uI), uR, UI=0, 1, . . . , N−1} where Z is a complex symbol and R,I are real symbols assigned to the real, imaginary communications axis. Examples of complex user symbols are QPSK and OQPSK encoded data corresponding to 4-phase and offset 4-phase symbol coding. Examples of real user symbols are PSK and DPSK encoded data corresponding to 2-phase and differential 2-phase symbol coding. Although not considered in this example, it is possible to use combinations of both complex and real data symbols.
Current real Walsh CDMA encoding for transmitter (1)
1 Walsh codes
                    W        =                ⁢                  Walsh          ⁢                                          ⁢          N          ×          N          ⁢                                          ⁢          orthogonal          ⁢                                          ⁢          code          ⁢                                          ⁢          matrix          ⁢                                          ⁢          consisting          ⁢                                          ⁢          of                                                                            ⁢                  N          ⁢                                          ⁢          rows          ⁢                                          ⁢          of          ⁢                                          ⁢          N          ⁢                                          ⁢          chip          ⁢                                          ⁢          code          ⁢                                          ⁢          vectors                                                                    =                ⁢                              [                          W              ⁡                              (                u                )                                      ]                    ⁢                                          ⁢          matrix          ⁢                                          ⁢          of          ⁢                                          ⁢          row          ⁢                                          ⁢          vectors          ⁢                                          ⁢                      W            ⁡                          (              u              )                                                                                          =                ⁢                              [                          W              ⁡                              (                                  u                  ,                  n                                )                                      ]                    ⁢                                          ⁢          matrix          ⁢                                          ⁢          of          ⁢                                          ⁢          elements          ⁢                                          ⁢                      W            ⁡                          (                              u                ,                n                            )                                                                                                                W            ⁡                          (              u              )                                =                    ⁢                                    Walsh              ⁢                                                          ⁢              code              ⁢                                                          ⁢              vector              ⁢                                                          ⁢              u              ⁢                                                          ⁢              for              ⁢                                                          ⁢              u                        ⁢                                                  =                                                  ⁢            0                          ,        1        ,                                  ⁢        …        ⁢                                  ,                  N          -          1                                                                              =                    ⁢                      [                                          W                ⁡                                  (                                      u                    ,                    0                                    )                                            ,                              W                ⁡                                  (                                      u                    ,                    1                                    )                                            ,                                                          ⁢              …              ⁢                                                          ,                                                          ⁢                              W                ⁡                                  (                                      u                    ,                                          N                      -                      1                                                        )                                                      ]                          ⁢                                                                                                =                    ⁢                      1            ×            N            ⁢                                                  ⁢            row            ⁢                                                  ⁢            vector            ⁢                                                  ⁢            of            ⁢                                                  ⁢            chips            ⁢                                                  ⁢                          W              (                              u                ,                0                            )                                      ,                                  ⁢        …        ⁢                                  ,                  W          ⁡                      (                          u              ,                              N                -                1                                      )                                                                                        W          ⁡                      (                          u              ,              n                        )                          =                ⁢                  Walsh          ⁢                                          ⁢          code          ⁢                                          ⁢          u          ⁢                                          ⁢          chip          ⁢                                          ⁢          n                                                                    =                ⁢                              +                          /                                +                      1            ⁢                                                  ⁢            possible            ⁢                                                  ⁢            values                                                          
2 Data symbols                Z(u)=Complex data symbol for user u        R(UR)=Real data symbol for user UR assigned to the Real axis of the CDMA signal        I (uI)=Real data symbol for user uI assigned to th Imaginary axis of the CDMA signal        
3 Walsh encoded data
Complex data symbols
                              Z          ⁡                      (                          u              ,              n                        )                          =                ⁢                              Z            ⁡                          (              u              )                                ⁢                                          ⁢          sgn          ⁢                      {                          W              ⁡                              (                                  u                  ,                  n                                )                                      }                                                  =                ⁢                  User          ⁢                                          ⁢          u          ⁢                                          ⁢          chip          ⁢                                          ⁢          n          ⁢                                                            ⁢                                                          ⁢          Walsh          ⁢                                          ⁢          encoded          ⁢                                          ⁢          complex          ⁢                                          ⁢          data                    
Real data symbols
                              R          ⁡                      (                                          u                R                            ,              n                        )                          =                ⁢                              R            ⁡                          (                              u                R                            )                                ⁢                                          ⁢          sgn          ⁢                      {                          W              ⁡                              (                                                      u                    R                                    ,                  n                                )                                      }                                                  =                ⁢                  User          ⁢                                          ⁢                      u            R                    ⁢                                          ⁢          chip          ⁢                                          ⁢          n          ⁢                                          ⁢          Walsh          ⁢                                          ⁢          encoded                                                ⁢                  real          ⁢                                          ⁢          data                                                  I          ⁡                      (                                          u                I                            ,              n                        )                          =                ⁢                              R            ⁡                          (                              u                R                            )                                ⁢                                          ⁢          sgn          ⁢                      {                          W              ⁡                              (                                                      u                    R                                    ,                  n                                )                                      }                                                  =                ⁢                  User          ⁢                                          ⁢                      u            I                    ⁢                                          ⁢          chip          ⁢                                          ⁢          n          ⁢                                          ⁢          Walsh          ⁢                                          ⁢          encoded                                                ⁢                  real          ⁢                                          ⁢          data                                    where sgn{(o)}=Algeraic sign of “(o)”        
4 PN scrambling                P2(n),PR2(n), PI2(n)=Chip n of long PN codes        PR(n)=Chip n of short PN code for real axis        PI(n)=Chip n of short PN code for imaginary axis        
Complex data symbols:
                                          Z            ⁡                          (              n              )                                =                    ⁢                      PN            ⁢                                                  ⁢            scrambled            ⁢                                                  ⁢            Walsh            ⁢                                                  ⁢            encoded            ⁢                                                  ⁢            data            ⁢                                                  ⁢            chips            ⁢                                                  ⁢            after            ⁢                                                  ⁢            summing            ⁢                                                  ⁢            over                          ⁢                                                                  ⁢                  the          ⁢                                          ⁢          users                                        =                ⁢                              ∑            n                    ⁢                                    Z              ⁡                              (                                  u                  ,                  n                                )                                      ⁢                                                            P                  2                                ⁡                                  (                  n                  )                                            ⁡                              [                                                                            P                      R                                        ⁡                                          (                      n                      )                                                        +                                                            jP                      I                                        ⁡                                          (                      n                      )                                                                      ]                                                                            =                ⁢                              ∑            u                    ⁢                                    Z              ⁡                              (                                  u                  ,                  n                                )                                      ⁢            sgn            ⁢                                          {                                                      P                    2                                    ⁡                                      (                    n                    )                                                  }                            ⁡                              [                                                      sgn                    ⁢                                          {                                                                        P                          R                                                ⁡                                                  (                          n                          )                                                                    }                                                        +                                      j                    ⁢                                                                                  ⁢                    sgn                    ⁢                                          {                                                                        P                          I                                                ⁡                                                  (                          n                          )                                                                    }                                                                      ]                                                                            =                ⁢                  Real          ⁢                                          ⁢          Walsh          ⁢                                          ⁢          CDMA          ⁢                                          ⁢          encoded          ⁢                                          ⁢          complex          ⁢                                          ⁢          chips                    
Real data symbols:
                              Z          ⁡                      (            n            )                          =                ⁢                  [                                                    ∑                                  u                  R                                            ⁢                                                R                  ⁡                                      (                                                                  u                        R                                            ,                      n                                        )                                                  ⁢                sgn                ⁢                                  {                                                            P                      R2                                        ⁡                                          (                      n                      )                                                        }                                                      +                          j              ⁢                                                ∑                                      u                    I                                                  ⁢                                                      I                    ⁡                                          (                                                                        u                          I                                                ,                        n                                            )                                                        ⁢                  sgn                  ⁢                                                            {                                                                        P                          I2                                                ⁡                                                  (                          n                          )                                                                    }                                        [                                                                  sgn                        ⁢                                                  {                                                                                    P                              R                                                        ⁡                                                          (                              n                              )                                                                                }                                                                    +                                                                                                                                          ⁢                  j          ⁢                                          ⁢          sgn          ⁢                      {                                          P                I                            ⁡                              (                n                )                                      }                          ]                                =                ⁢                  Real          ⁢                                          ⁢          Walsh          ⁢                                          ⁢          CDMA          ⁢                                          ⁢          encoded          ⁢                                          ⁢          real          ⁢                                          ⁢          chips                    
User data is encoded by the Walsh CDMA codes 3. Each of the user symbols Z(u) R (uR), I(uI) is assigned a unique Walsh code. W(u),W(uR),W(uI). Walsh encoding of each user data symbol generates an N-chip sequence with each chip in the sequence consisting of the user data symbol with the sign of the corresponding Walsh code chip, which means each chip =[Data symbol]×[Sign of Walsh chip].
The Walsh encoded data symbols are summed and encoded with PN codes 4. These long PN codes are 2-phase with each chip equal to +/−1 which means PN encoding consists of sign changes with each sign change corresponding to the sign of the PN. chip. Short PN codes are complex with 2-phase codes along their real and imaginary axes. Encoding with a long PN means each chip of the summed Walsh encoded data symbols has a sign change when the corresponding long PN chip is −1, and remains unchanged for +1 values. This operation is described by a multiplication of each chip of the summed Walsh encoded data symbols with the sign of the PN chip. Purpose of the PN encoding is to provide scrambling of the summed Walsh encoded data symbols as well as isolation between groups of users and synchronization. PN encoding uses a long PN which is real followed by a short PN which is complex with real code components on the inphase and quadrature axes as shown in 4.
Receiver equations (2) describe a representative Walsh CDMA decoding for the receiver in FIG. 3. The receiver front end 5 provides estimates {{circumflex over (Z)}(n)={circumflex over (R)}(n)+j Î(n)} of the transmitted real Walsh CDMA encoded chips {Z(n)=R(n)+jI(n)} for the complex and real data symbols. Orthogonality property 6 is expressed as a matrix product of the Walsh code chips or equivalently as a matrix product of the Walsh code chip numerical signs. Decoding algorithms 8 perform the inverse of the signal processing for the encoding in equations (1) to recover estimates {{circumflex over (Z)}(u)} or {{circumflex over (R)}(uR), Î(uI)} of the transmitter user symbols {Z(u)} or {R(uR), I(uI)} for the respective complex or real data symbols.
Current real Walsh CDMA decoding for receiver (2)
5 Receiver front end provides estimates {{circumflex over (Z)}(n)={circumflex over (R)}(n)+jÎ(n)}} of the encoded transmitter chip symbols {Z(n)=R(n)+jI(n)} for the complex and real data symbols
6 Orthogonality property of Walsh N×N.matrix W
                                          ∑            n                    ⁢                                    W              ⁡                              (                                                      u                    ^                                    ,                  n                                )                                      ⁢                          W              ⁡                              (                                  n                  ,                  u                                )                                                    =                ⁢                              ∑            n                    ⁢                      sign            ⁢                          {                              W                ⁡                                  (                                                            u                      ^                                        ,                    n                                    )                                            }                        ⁢            sign            ⁢                          {                              W                ⁡                                  (                                      n                    ,                    u                                    )                                                                                            =                ⁢                  N          ⁢                                          ⁢                      δ            ⁡                          (                                                u                  ^                                ,                n                            )                                                                        where          ⁢                                          ⁢                      δ            ⁡                          (                                                u                  ^                                ,                u                            )                                      =                ⁢                  Delta          ⁢                                          ⁢          function          ⁢                                          ⁢          of          ⁢                                          ⁢                      u            ^                    ⁢                                          ⁢          and          ⁢                                          ⁢          u                                        =                ⁢                              1            ⁢                                                  ⁢            for            ⁢                                                  ⁢                          u              ^                                =          u                                        =                ⁢                  0          ⁢                                          ⁢          otherwise                    
7 PN decoding property:
                                                        P              2                        ⁡                          (              n              )                                ⁢                                    P              2                        ⁡                          (              n              )                                      =                ⁢                  sgn          ⁢                      {                                                            P                  2                                ⁡                                  (                  n                  )                                            ⁢              sgn              ⁢                              {                                                      P                    2                                    ⁡                                      (                    n                    )                                                  }                                                                            =                ⁢        1            
Decoding algorithm:
Complex Data Symbols
                                          Z            ^                    ⁡                      (            u            )                          =                ⁢                              2                          -              1                                ⁢                      N                          -              1                                ⁢                                    ∑              n                        ⁢                                                                                Z                    ^                                    ⁡                                      (                    n                    )                                                  ⁡                                  [                                                            sign                      ⁢                                              {                                                                              P                            2                                                    ⁡                                                      (                            n                            )                                                                          }                                                              -                                          j                      ⁢                                                                                          ⁢                      sign                      ⁢                                              {                                                                              P                            I                                                    ⁡                                                      (                            n                            )                                                                          }                                                                              ]                                            ⁢              sgn              ⁢                              {                                  W                  ⁡                                      (                                          n                      ,                      u                                        )                                                  }                                                                            =                ⁢                  Receiver          ⁢                                          ⁢          estimate          ⁢                                          ⁢          of          ⁢                                          ⁢          the          ⁢                                          ⁢          transmitted          ⁢                                          ⁢          complex          ⁢                                          ⁢          data          ⁢                                          ⁢          symbol          ⁢                                          ⁢                      Z            ⁡                          (              u              )                                          
Real Data Symbols
                                          R            ^                    ⁡                      (                          u              R                        )                          =                ⁢                  Real          [                                    2                              -                1                                      ⁢                          N                              -                1                                      ⁢                                          ∑                n                            ⁢                                                                    Z                    ^                                    ⁡                                      (                    n                    )                                                  ⁡                                  [                                                            sgn                      ⁢                                              {                                                                              P                            R                                                    ⁡                                                      (                            n                            )                                                                          }                                                              -                                          j                      ⁢                                                                                          ⁢                      sgn                      ⁢                                              {                                                                              P                            1                                                    ⁡                                                      (                            n                            )                                                                          }                                                                              ]                                                                                                    ⁢                  sgn          ⁢                      {                                          P                2                            ⁡                              (                n                )                                      }                    ⁢          sgn          ⁢                      {                          W              ⁡                              (                                  n                  ,                                      u                    R                                                  )                                      }                                                  =                ⁢                  Receiver          ⁢                                          ⁢          estimate          ⁢                                          ⁢          of          ⁢                                          ⁢          the          ⁢                                          ⁢          transmitted          ⁢                                          ⁢          complex          ⁢                                          ⁢          data          ⁢                                          ⁢          symbol          ⁢                                          ⁢                      R            ⁡                          (                              u                R                            )                                                                        I          ⁡                      (                          u              I                        )                          =                ⁢                  Imag          [                                    2                              -                1                                      ⁢                          N                              -                1                                      ⁢                                          ∑                n                            ⁢                                                                    Z                    ^                                    ⁡                                      (                    n                    )                                                  ⁡                                  [                                                            sgn                      ⁢                                              {                                                                              P                            R                                                    ⁡                                                      (                            n                            )                                                                          }                                                              -                                          j                      ⁢                                                                                          ⁢                      sgn                      ⁢                                              {                                                                              P                            1                                                    ⁡                                                      (                            n                            )                                                                          }                                                                              ]                                                                                                    ⁢                  sgn          ⁢                      {                                          P                2                            ⁡                              (                n                )                                      }                    ⁢          sgn          ⁢                      {                          W              ⁡                              (                                  n                  ,                                      u                    I                                                  )                                      }                                                  =                ⁢                  Receiver          ⁢                                          ⁢          estimate          ⁢                                          ⁢          of          ⁢                                          ⁢          the          ⁢                                          ⁢          transmitted          ⁢                                          ⁢          complex          ⁢                                          ⁢          data          ⁢                                          ⁢          symbol          ⁢                                          ⁢                      I            ⁡                          (                              u                I                            )                                          
FIG. 1 CDMA transmitter block diagram is representative of a current CDMA transmitter which includes an implementation of the current real Walsh CDMA channelization encoding in equations (1). This block diagram becomes a representative implementation of the CDMA transmitter which implements the complex Walsh CDMA encoding of this invention disclosure when the current real Walsh CDMA encoding 13 is replaced by the complex Walsh CDMA encoding. Signal processing starts with the stream of user input data words 9. Frame processor 10 accepts these data words and performs the encoding and frame formatting, and passes the outputs to the symbol encoder 11 which encodes the frame symbols into amplitude and phase coded symbols 12 which could. be complex IZ(u).} or real {R(uR), I(uI)) depending on the application. These symbols 12 are the inputs to the current real Walsh CDMA encoding in equations (1). Inputs {Z(u)}, {R(uR), I (uI)) 12 are Walsh encoded, summed over the users, and scrambled by PN in the current Walsh CDMA encoder 13 to generate the complex output chips {Z(n)} 14. This encoding 13 is a representative implementation of equations (1). These output chips. Z (n) are waveform modulated 15 to generate the analog complex signal z(t) which is single sideband upconverted, amplified, and transmitted (Tx) by the analog front end. of the transmitter 15 as the real waveform v(t) 16 at the carrier frequency f0 whose amplitude is the real part of the complex envelope of the baseband waveform z(t) multiplied by the carrier frequency and the phase angle φ accounts for the phase change from the baseband signal to the transmitted signal.
FIG. 2 real Walsh CDMA encoding is a representative implementation of the Walsh CDMA encoding 13 in FIG. 1 and in equations (1). Inputs are the user data symbols which could be complex {Z(u)} or real {R(uR), I(uI)} 17. For complex and real data symbols the encoding of each user by the corresponding Walsh code is described in 18 by the implementation of transferring the sign of each Walsh code chip to the user data symbol followed by a 1-to-N expander 1↑N of each data symbol into an N chip sequence using the sign transfer of the Walsh chips.
For complex data symbols {Z(u)} the sign-expander operation 18 generates the N-chip sequence Z(u,n)=Z(u)sgn{W(u,n)}=.Z(u)W(u,n) for n=0 μl, . . . ,N−1 for each user u=0 μl, . . . ,N−1. This Walsh encoding serves to spread each user data symbol into an orthogonally encoded chip sequence which is spread over the CDMA communications frequency band. The Walsh encoded chip sequences for each of the user data symbols are summed over the users 19 and encoded with a long code P2(n) followed by a short code [PR(n)+jPI(n)] 21. Output is the stream of complex CDMA encoded chips {Z(n)} 22. The switch 20 selects the appropriate signal processing path for the complex and real data symbols.
For real data symbols {R(uR), jI(uI)} the real and imaginary communications axis data symbols are separately Walsh encoded 18, summed 19, and then PN encoded 19 with long codes PR2(n) for the real axis and PI2(n) for the imaginary axis to provide orthogonality between the channels along the real and imaginary communications axes. Output is complex combined 19 and PN encoded with the short PN sequence [PR(n)+jPI,(n)] 21. Output is the stream of complex CDMA encoded chips {Z(n)} 22.
FIG. 3 CDMA receiver block diagram is representative of a current CDMA receiver which includes an implementation of the current real Walsh CDMA decoding in equations (2). This block diagram becomes a representative implementation of the CDMA receiver which implements the complex Walsh CDMA decoding when the current real Walsh CDMA decoding 27 is replaced by the complex Walsh CDMA decoding of this invention. FIG. 3 signal processing starts with the user transmitted wavefronts incident at the receiver antenna 23 for the nu users u=1, . . . , nu≦Nc. These wavefronts are combined by addition in the antenna to form the receive (Rx) signal {circumflex over (v)}(t) at the antenna output 23 where {circumflex over (v)}(t) is an estimate of the transmitted signal v(t) 16 in FIG. 1, that is received with errors in time Δt, frequency Δf, phase Δθ, and with an estimate {circumflex over (z)}(t) of the transmitted complex baseband signal z(t) 16 in FIG. 1. This received signal {circumflex over (v)}(t) is amplified and downconverted by the analog front end 24 and then synchronized (synch.) and analog-to-digital (ADC) converted 25. Outputs from the ADC are filtered and chip detected 26 by the fullband chip detector, to recover estimates {{circumflex over (Z)}(n)={circumflex over (R)}(n)+jÎ(n)}} 28 of the transmitted signal which is the stream of complex CDMA encoded chips {Z(n)=R(n)+jI(n)} 14 in FIG. 1 for both complex and real data symbols. The CDMA decoder 27 implements the algorithms in equations (2) by stripping off the PN codes and decoding the received CDMA real Walsh orthogonally encoded chips to recover estimates {{circumflex over (Z)}(u)={circumflex over (R)}(uR)+jÎ(u1)} 29 of the transmitted user data symbols {Z(u)=R(uR)+jI(uI)} 12 in FIG. 1. Notation introduced in FIGS. 1 and 3 assumes that the user index U=uR=uI for complex data symbols, and for real data symbols the user index u is used for counting the user pairs (uR, uI) of real and complex data symbols. These estimates are processed by the symbol decoder 30 and the frame processor 31 to recover estimates 32 of the transmitted user data words.
FIG. 4 real Walsh CDMA decoding is a representative implementation of the real Walsh CDMA decoding 27 in FIG. 3 and in equations (2). Inputs are the received estimates of the complex CDMA encoded chips {{circumflex over (Z)}(n)} 33. The PN codes are stripped off from these chips 34 by multiplying by the numerical sign of the real and imaginary components of the complex conjugate of the PN code as per the decoding algorithms 7 in equations (2).
For complex data symbols 35 the long PN code is stripped off and the real Walsh channelization coding is removed by a pulse compression operation consisting of multiplying each received chip by the numerical sign of the corresponding Walsh chip for the user, scaling by 1/2N, and summing the products over the N Walsh chips 36 to recover estimates {{circumflex over (Z)}(u)} of the user complex data symbols {Z(u)}. The switch 35 selects the appropriate signal processing path for the complex and real data symbols.
For real data symbols 35 the next signal processing operation is the removal of the remaining PN codes from the real and imaginary axes. This is followed by stripping off the Walsh channelization coding by multiplying each received chip by the numerical sign of the corresponding Walsh chip for the user, scaling by 1/2N, and summing the products over the N Walsh chips 36 to recover estimates ({circumflex over (R)}(uR), Î(u1)} of the user real data symbols {R(uR), I(uI)}.
It should be obvious to anyone skilled in the communications art that these example implementations clearly define the fundamental current CDMA signal processing relevant to this invention disclosure and it is obvious that these examples are representative of the other possible signal processing approaches.
For cellular applications the transmitter description describes the transmission signal processing applicable of this invention for both the hub and user terminals, and the receiver describes the corresponding receiving signal processing for the hub and user terminals for applicability of this invention.